package com.gitee.wsl.platform.network.command

/**
 * Copyright (c) 2017-2024 Nop Platform. All rights reserved.
 * Author: canonical_entropy@163.com
 * Blog:   https://www.zhihu.com/people/canonical-entropy
 * Gitee:  https://gitee.com/canonical-entropy/nop-entropy
 * Github: https://github.com/entropy-cloud/nop-entropy
 *
 * package io.nop.socket;
 */

class BinaryCommand(
    val masks: Short,
    val version: Short,
    val cmd: Short = 0.toShort(),
    val flags: Short = 0.toShort(),
    val data: ByteArray = EMPTY_BYTES,
) {
    companion object{
        val EMPTY_BYTES: ByteArray = ByteArray(0)
    }
}



//class BinaryCommand @JvmOverloads constructor(
//    val masks: Short,
//    val version: Short,
//    val cmd: Short = 0.toShort(),
//    val flags: Short = 0.toShort(),
//    val data: ByteArray = EMPTY_BYTES,
//) {
//
//    constructor(masks: Short, version: Short, cmd: Short, flags: Short, data: String) : this(
//        masks,
//        version,
//        cmd,
//        flags,
//        data.encodeToByteArray()
//    )
//
//    val isEmptyCommand: Boolean
//        get() = cmd.toInt() == 0 && flags.toInt() == 0 && data.isEmpty()
//
//    val dataAsString: String
//        get() {
//            if (data.isEmpty()) return ""
//            return data.decodeToString()
//        }
//
//    val packetLength: Int
//        get() = 4 + this.length
//
//    val length: Int
//        get() {
//            if (this.isEmptyCommand) return 4
//            return 8 + data.size
//        }
//
//    fun toPacket(): Buffer {
//        val len = this.length
//        val buf = Buffer(4 + len)
//        buf.writeInt(len)
//        writeTo(this, buf)
//        buf.rewind()
//        return buf
//    }
//
//    companion object {
//        val EMPTY_BYTES: ByteArray = ByteArray(0)
//
//        fun newEmptyCommand(masks: Short, version: Short): BinaryCommand {
//            return BinaryCommand(masks, version, 0.toShort(), 0.toShort(), EMPTY_BYTES)
//        }
//
//
//        fun writeTo(command: BinaryCommand, buffer: Buffer) {
//            buffer.putShort(command.masks)
//            buffer.putShort(command.version)
//
//            if (!command.isEmptyCommand) {
//                buffer.putShort(command.cmd)
//                buffer.putShort(command.flags)
//                buffer.put(command.data)
//            }
//        }
//
//        fun readFrom(buffer: Buffer): BinaryCommand {
//            val masks: Short = buffer.getShort()
//            val version: Short = buffer.getShort()
//
//            if (buffer.remaining() === 0) {
//                return BinaryCommand(masks, version, 0.toShort(), 0.toShort(), EMPTY_BYTES)
//            }
//
//            val cmd: Short = buffer.getShort()
//            val flags: Short = buffer.getShort()
//            val data = ByteArray(buffer.remaining())
//            buffer.get(data)
//            return BinaryCommand(masks, version, cmd, flags, data)
//        }
//
//        @Throws(IOException::class)
//        fun writePacketToStream(command: BinaryCommand, os: OutputStream) {
//            val buf: ByteBuffer = command.toPacket()
//            os.write(buf.array(), buf.arrayOffset(), buf.remaining())
//        }
//
//        @Throws(IOException::class)
//        fun readPacketFromStream(
//            `is`: Sink, masks: Short, minLen: Int, maxLen: Int, buf: Buffer,
//        ): BinaryCommand? {
//            buf.rewind()
//            if (!readFully(`is`, buf, 8)) {
//                if (buf.position() === 0) {
//                    return null
//                }
//                throw IOException("nop.err.socket.read-no-enough-data")
//            }
//            buf.limit(8)
//            val readMasks: Short = buf.getShort(4)
//            if (readMasks != masks) {
//                throw IOException("nop.err.socket.read-packet-masks-mismatch:masks=" + readMasks)
//            }
//            val version: Short = buf.getShort(6)
//
//            val len: Int = buf.getInt(0)
//            if (len < minLen) throw IOException("nop.err.socket.packet-is-too-small:len=" + len)
//            if (len > maxLen) throw IOException("nop.err.socket.packet-is-too-large:len=" + len)
//
//            val dataBuf: ByteBuffer = ByteBuffer.allocate(len)
//            dataBuf.putShort(masks)
//            dataBuf.putShort(version)
//
//            if (len > 4) {
//                if (!readFully(`is`, dataBuf.array(), 4, len - 4)) {
//                    throw IOException("nop.err.socket.packet-is-incomplete")
//                }
//            }
//            dataBuf.rewind()
//            return readFrom(dataBuf)
//        }
//
//        @Throws(IOException::class)
//        private fun readFully(`is`: Sink, buf: ByteArray?, offset: Int, n: Int): Boolean {
//            var offset = offset
//            var toRead = n
//            do {
//                val nRead: Int = `is`.read(buf, offset, toRead)
//                if (nRead <= 0) return false
//
//                toRead -= nRead
//                offset += nRead
//            } while (toRead > 0)
//            return true
//        }
//
//        @Throws(IOException::class)
//        fun readFully(`is`: InputStream, buf: ByteBuffer, n: Int): Boolean {
//            var toRead = n
//            val array: ByteArray? = buf.array()
//            val offset: Int = buf.arrayOffset()
//            var pos: Int = buf.position()
//            do {
//                val nRead: Int = `is`.read(array, offset + pos, toRead)
//                if (nRead <= 0) {
//                    buf.position(pos)
//                    return false
//                }
//
//                toRead -= nRead
//                pos += nRead
//            } while (toRead > 0)
//            buf.position(pos)
//            return true
//        }
//    }
//}